package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xuecheng.base.exception.XueChengPlusException;
import com.xuecheng.base.model.PageParams;
import com.xuecheng.base.model.PageResult;
import com.xuecheng.content.mapper.*;
import com.xuecheng.content.model.dto.AddCourseDto;
import com.xuecheng.content.model.dto.CourseBaseInfoDto;
import com.xuecheng.content.model.dto.EditCourseDto;
import com.xuecheng.content.model.dto.QueryCourseParamsDto;
import com.xuecheng.content.model.po.*;
import com.xuecheng.content.service.CourseBaseInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ws
 * Date: 2024-06-10
 * Time: 14:53
 */
@Slf4j
@Service
public class CourseBaseInfoServiceImpl implements CourseBaseInfoService {

    @Resource
    private CourseBaseMapper courseBaseMapper;

    @Resource
    private CourseMarketMapper courseMarketMapper;

    @Resource
    private CourseCategoryMapper courseCategoryMapper;

    @Resource
    private TeachPlanMapper teachPlanMapper;

    @Resource
    private CourseTeacherMapper courseTeacherMapper;


    /**
     * @param pageParams           分页参数
     * @param queryCourseParamsDto 分页查询条件
     * @description 课程查询接口
     */
    @Override
    public PageResult<CourseBase> queryCourseBaseList(Long companyId, PageParams pageParams, QueryCourseParamsDto queryCourseParamsDto) {
        // 1. 分页查询前置条件
        // 1.2 根据课程的名称(模糊查询)
        LambdaQueryWrapper<CourseBase> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(!StringUtils.isEmpty(queryCourseParamsDto.getCourseName()), CourseBase::getName, queryCourseParamsDto.getCourseName());
        // 1.3 根据课程的审核状态(精确查询)
        lambdaQueryWrapper.eq(!StringUtils.isEmpty(queryCourseParamsDto.getAuditStatus()), CourseBase::getAuditStatus, queryCourseParamsDto.getAuditStatus());
        // 1.4 根据课程的发布状态(精确查询)
        lambdaQueryWrapper.eq(!StringUtils.isEmpty(queryCourseParamsDto.getPublishStatus()), CourseBase::getStatus, queryCourseParamsDto.getPublishStatus());
        // 最终结果 SELECT id,company_id,company_name,name,users,tags,mt,st,grade,teachmode,description,pic,create_date,change_date,create_people,change_people,audit_status,status
        // FROM course_base
        // WHERE (name LIKE ?) LIMIT ?

        // 1.5 拼装机构id
        lambdaQueryWrapper.eq(CourseBase::getCompanyId, companyId);


        Page<CourseBase> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 3. 开始进行分页查询
        Page<CourseBase> courseBasePage = courseBaseMapper.selectPage(page, lambdaQueryWrapper);
        // 4. 使用统一的结构响应对象
        PageResult<CourseBase> pageResult = new PageResult<>(courseBasePage.getRecords(), courseBasePage.getTotal(), courseBasePage.getCurrent(), courseBasePage.getSize());
        log.info("分页查询结果：{}", pageResult);
        return pageResult;
    }

    @Transactional // 增删改都要加事务
    @Override
    public CourseBaseInfoDto createCourseBase(Long companyId, AddCourseDto dto) {
        // 参数的合法性校验，手工校验
        // 也可以在 Controller 层使用 @Validated
//        if (StringUtils.isEmpty(dto.getName())) {
//            throw new RuntimeException("课程名称为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getMt())) {
//            throw new RuntimeException("课程分类为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getSt())) {
//            throw new RuntimeException("课程分类为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getGrade())) {
//            throw new RuntimeException("课程等级为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getTeachmode())) {
//            throw new RuntimeException("教育模式为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getUsers())) {
//            throw new RuntimeException("适应人群为空");
//        }
//
//        if (StringUtils.isEmpty(dto.getCharge())) {
//            throw new RuntimeException("收费规则为空");
//        }

        // 向课程基本信息表 course_base 插入数据
        CourseBase courseBase = new CourseBase();
        // 将 dto 放入 courseBase
        BeanUtils.copyProperties(dto, courseBase);
        // 没有对应的属性，手动拷贝
        courseBase.setCompanyId(companyId);
        courseBase.setCreateDate(LocalDateTime.now());
        // 审核状态，默认为未提交 202002
        courseBase.setAuditStatus("202002");
        // 发布状态，默认为未发布 203001
        courseBase.setStatus("203001");
        // MP 插入成功后会自动将 id 赋值给 courseBase
        int insert = courseBaseMapper.insert(courseBase);
        if (insert <= 0) {
            throw new RuntimeException("添加课程失败");
        }
        // course_base 和 course_market 是一对一关系，所以需要拿到 course_base 的 id
        // 向课程营销表 course_market 插入数据
        CourseMarket courseMarket = new CourseMarket();
        BeanUtils.copyProperties(dto, courseMarket);
        // 拿到课程 id
        Long courseId = courseBase.getId();
        courseMarket.setId(courseId);
        int i = saveCourseMarket(courseMarket);
        if (i <= 0) {
            throw new RuntimeException("添加课程营销失败");
        }
        // 再从数据库中将插入的信息全部查询出来
        CourseBaseInfoDto courseBaseInfoDto = getCourseBaseInfo(courseId);


        return courseBaseInfoDto;
    }

    /**
     * 根据课程 id 查询课程基本信息
     *
     * @param courseId 课程 id
     * @return 返回课程的基本信息
     */
    @Override
    public CourseBaseInfoDto getCourseBaseInfo(Long courseId) {
        CourseBaseInfoDto courseBaseInfoDto = new CourseBaseInfoDto();
        // 从数据库中查询课程基本信息
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if (courseBase == null) {
            return null;
        }
        // 从数据库中查询课程营销信息
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        // 组装在一起
        BeanUtils.copyProperties(courseBase, courseBaseInfoDto);
        BeanUtils.copyProperties(courseMarket, courseBaseInfoDto);

        // 大分类名称 mtName，小分类名称 stName，存的都是代码 1-1，1-1-2
        // 但是我们不能给前端返回这些代码，所以需要从数据库中查询出对应的课程分类名称
        CourseCategory courseCategory = courseCategoryMapper.selectById(courseBase.getMt());
        if (courseCategory != null) {
            courseBaseInfoDto.setMtName(courseCategory.getName());
        }
        courseCategory = courseCategoryMapper.selectById(courseBase.getSt());
        if (courseCategory != null) {
            courseBaseInfoDto.setStName(courseCategory.getName());
        }


        return courseBaseInfoDto;
    }

    @Override
    public CourseBaseInfoDto updateCourseBase(Long companyId, EditCourseDto editCourseDto) {
        // 数据合法性校验
        // 参数的校验在 controller 层已经被 @Validated 校验了
        // 这里校验查询逻辑，即：本机构只能修改本机构的课程
        Long courseId = editCourseDto.getId();
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }
        if (!companyId.equals(courseBase.getCompanyId())) {
            XueChengPlusException.cast("本机构只能修改本机构的课程");
        }
        // 封装数据
        BeanUtils.copyProperties(editCourseDto, courseBase);
        // 修改时间需要手动添加
        courseBase.setChangeDate(LocalDateTime.now());
        // 更新数据库
        int i = courseBaseMapper.updateById(courseBase);
        if (i <= 0) {
            XueChengPlusException.cast("修改课程失败");
        }
        // 更新营销消息
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        if (courseMarket == null) {
            XueChengPlusException.cast("课程营销信息不存在");
        }
        BeanUtils.copyProperties(editCourseDto, courseMarket);
        i = courseMarketMapper.updateById(courseMarket);
        if (i <= 0) {
            XueChengPlusException.cast("修改课程营销失败");
        }
        // 再从数据库中查询出课程信息
        CourseBaseInfoDto courseBaseInfoDto = getCourseBaseInfo(courseId);
        return courseBaseInfoDto;
    }


    /**
     * 保存课程营销信息
     *
     * @param courseMarketNew 课程营销信息
     * @return 返回插入或更新的状态
     */
    private int saveCourseMarket(CourseMarket courseMarketNew) {
        // 收费规则
        String charge = courseMarketNew.getCharge();
        if (StringUtils.isEmpty(charge)) {
            throw new RuntimeException("收费规则没有选择");
        }
        // 收费规则必须合法
        if (charge.equals("201001")) {
            if (courseMarketNew.getPrice() == null || courseMarketNew.getPrice() <= 0) {
                throw new RuntimeException("课程为收费价格不能为空且必须大于0");
            }
        }
        // 从数据库中查询营销信息，如果存在则更新，不存在添加
        CourseMarket courseMarket = courseMarketMapper.selectById(courseMarketNew.getId());
        if (courseMarket == null) {
            // 插入
            return courseMarketMapper.insert(courseMarketNew);
        } else {
            // 更新
            BeanUtils.copyProperties(courseMarketNew, courseMarket);
            courseMarket.setId(courseMarketNew.getId());
            return courseMarketMapper.updateById(courseMarket);
        }


    }

    @Override
    public void deleteCourseBase(Long courseId) {
        CourseBase courseBase = courseBaseMapper.selectById(courseId);
        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }
        //课程的审核状态为未提交时方可删除。
        if (!courseBase.getAuditStatus().equals("202002")) {
            XueChengPlusException.cast("课程审核状态为未提交时方可删除");
        }
        // 删除课程需要删除课程相关的基本信息、营销信息、课程计划、课程教师信息。
        // 删除课程基本信息
        courseBaseMapper.deleteById(courseId);
        // 删除课程营销信息，markId 和 courseId 一一对应
        courseMarketMapper.deleteById(courseId);
        // 删除课程计划
        teachPlanMapper.delete(Wrappers.<TeachPlan>lambdaQuery().eq(TeachPlan::getCourseId, courseId));
        // 删除课程教师信息
        courseTeacherMapper.delete(Wrappers.<CourseTeacher>lambdaQuery().eq(CourseTeacher::getCourseId, courseId));
    }


}
